﻿#define  _CRT_SECURE_NO_WARNINGS

//#include <iostream>
//#include <assert.h>
//using namespace std;
//
//typedef int STDataType;
//
//class Stack
//{
//public:
//	// 成员函数
//	void Init(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//
//	void Push(STDataType x)
//	{
//		if (_top == _capacity)
//		{
//			int newcapacity = _capacity * 2;
//			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
//				sizeof(STDataType));
//			if (tmp == NULL)
//			{
//				perror("realloc fail");
//				return;
//			}
//			_a = tmp;
//			_capacity = newcapacity;
//		}
//		_a[_top++] = x;
//}
//	void Pop()
//	{
//		assert(_top > 0);
//		--_top;
//	}
//	bool Empty()
//	{
//		return _top == 0;
//	}
//	int Top()
//	{
//		assert(_top > 0);
//		return _a[_top - 1];
//	}
//	void Destroy()
//	{
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	// 成员变量
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//int main()
//{
//	Stack s;
//	s.Init();
//	s.Push(1);
//	s.Push(2);
//	s.Push(3);
//	s.Push(4);
//	while (!s.Empty())
//	{
//		printf("%d\n", s.Top());
//		s.Pop();
//	}
//	s.Destroy();
//	return 0;
//}

//#include<stdio.h>
//#include<stdlib.h>
//#include<stdbool.h>
//#include<assert.h>
//
//typedef int STDataType;
//
//typedef struct Stack
//{
//	STDataType* a;
//	int top;
//	int capacity;
//}ST;
//
//void STInit(ST* ps)
//{
//	assert(ps);
//	ps->a = NULL;
//	ps->top = 0;
//	ps->capacity = 0;
//}
//
//void STDestroy(ST* ps)
//{
//	assert(ps);
//	free(ps->a);
//	ps->a = NULL;
//	ps->top = ps->capacity = 0;
//}
//
//void STPush(ST* ps, STDataType x)
//{
//	assert(ps);
//	// 满了， 扩容
//	if (ps->top == ps->capacity)
//	{
//		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *
//			sizeof(STDataType));
//		if (tmp == NULL)
//		{
//			perror("realloc fail");
//			return;
//		}
//		ps->a = tmp;
//		ps->capacity = newcapacity;
//	}
//	ps->a[ps->top] = x;
//	ps->top++;
//}
//
//bool STEmpty(ST* ps)
//{
//	assert(ps);
//	return ps->top == 0;
//}
//
//void STPop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	ps->top--;
//}
//
//STDataType STTop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	return ps->a[ps->top - 1];
//}
//
//int STSize(ST* ps)
//{
//	assert(ps);
//	return ps->top;
//}
//
//int main()
//{
//	ST s;
//	STInit(&s);
//	STPush(&s, 1);
//	STPush(&s, 2);
//	STPush(&s, 3);
//	STPush(&s, 4);
//	while (!STEmpty(&s))
//	{
//		printf("%d\n", STTop(&s));
//		STPop(&s);
//	}
//	STDestroy(&s);
//	return 0;
//}

// 显⽰写析构，也会⾃动调⽤Stack的析构
/*~MyQueue()
{}*/

//#include<iostream>
//using namespace std;
//typedef int STDataType;
//
//class Stack
//{
//public:
//	//默认构造函数
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	//析构函数
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//// 两个Stack实现队列
//class MyQueue
//{
//public:
//	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
//	
//	// 显⽰写析构，也会⾃动调⽤Stack的析构
//	/*~MyQueue()
//	{}*/
//
//private:
//	Stack pushst;
//	Stack popst;
//};
//int main()
//{
//	Stack st;
//	MyQueue mq;
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//加上const保护被拷贝对象不被改变
//	//传引用一般都要加const
//	//Date(const Date& d)
//	//{
//	//	_year = d._year;
//	//	_month = d._month;
//	//	_day = d._day;
//	//}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1(2024, 7, 29);
//	d1.Print();
//
//	//拷贝构造
//	Date d2(d1);
//	//Date d2(&d2, d1);
//	d2.Print();
//
//	return 0;
//}

//#include <iostream>
//#include <stdlib.h>
//#include <string.h>
//using namespace std;
//
//typedef int STDataType;
//
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc fail");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//
//	void Push(STDataType x)
//	{
//		if (_top == _capacity)
//		{
//			STDataType* tmp = (STDataType*)realloc(_a, sizeof(STDataType) * 2 * _capacity);
//			if (nullptr == tmp)
//			{
//				perror("realloc fail");
//				return;
//			}
//			_a = tmp;
//			tmp = nullptr;
//			_capacity *= 2;
//		}
//		_a[_top] = x;
//		_top++;
//	}
//
//	//Stack st2 = st1;
//	Stack(const Stack& st)
//	{
//		//需要对_a指向资源创建同样大小的资源再拷贝值
//		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
//		if (nullptr == _a)
//		{
//			perror("malloc fail");
//			return;
//		}
//		memcpy(_a, st._a, sizeof(STDataType) * st._top);
//		_top = st._top;
//		_capacity = st._capacity;
//	}
//
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//
//private:
//	STDataType* _a;
//	int _top;
//	int _capacity;
//};
//
////两个栈实现队列
//class MyQueue
//{
//public:
//	//...
//private:
//	Stack pushst;
//	Stack popst;
//};
//
//int main()
//{
//	Stack st1;
//	st1.Push(1);
//	st1.Push(2);
//	st1.Push(3);
//
//	//如果我们不显示实现拷贝构造，则编译器自动生成的拷贝构造会完成浅拷贝
//	//会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
//
//	//下面这两种实现的效果一样
//	//Stack st2(st1);
//	Stack st2 = st1;
//
//	MyQueue mq1;
//	//MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst
//	//的拷⻉
//	//只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
//	MyQueue mq2 = mq1;
//
//	return 0;
//}

//#include <iostream>
//using namespace std;
//
//class Date
//{
//public:
//	//构造
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//拷贝构造
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	//赋值运算符重载
//	//d1 = d2;
//	Date& operator=(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//		return *this;
//	}
//	
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1(2024, 7, 29);
//	Date d2(2004, 11, 7);
//
//	//赋值重载
//	d1 = d2;
//
//	//拷贝构造
//	Date d3(d2);
//	Date d4 = d2;
//
//	return 0;
//}